﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Spring.Context;
using Spring.Context.Support;
using NUnit.Framework;
using Studio7i.CapaDominio;
using Studio7i.CapaPersistencia;
using Studio7i.CapaPersistencia.DAO;

namespace Studio7i.CapaPruebas
{
    [TestFixture]
    public class Test_AdministradorDAO
    {

        private IAdministradorDAO adminDAO = null;
        private int codigoGenerado = 0;

        [TestFixtureSetUp]
        public void PrepararPruebas()
        {
            //1. Definimos la implementacion del DAO a probar 
            adminDAO = new AdministradorDAO();

            //2. Eliminar todo los locales en BD antes de las pruebas
            foreach (Administrador administrador in adminDAO.ListarTodos())
                adminDAO.Eliminar(administrador);

            //3. Creamos 2 locales para tenerlos disponibles en las pruebas
            foreach (Administrador i in adminDAO.ListarTodos()) adminDAO.Eliminar(i);
            adminDAO.Crear(new Administrador() { NoAdministrador = "Jose Perez", TxMail = "peslion@gmail.com", FeNacimiento = "05/08/1978", TxtClave = "2010" });
            adminDAO.Crear(new Administrador() { NoAdministrador = "Hugo Palomino", TxMail = "hpalo@gmail.com", FeNacimiento = "03/01/1976", TxtClave = "1222" });
            adminDAO.Crear(new Administrador() { NoAdministrador = "Martin Peros", TxMail = "mperos@gmail.com", FeNacimiento = "08/09/1980", TxtClave = "4321" });
            adminDAO.Crear(new Administrador() { NoAdministrador = "LarryLescano", TxMail = "larrylescano@gmail.com", FeNacimiento = "12/12/1978", TxtClave = "2009" });
        }
        //°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°° FIN DE TEST CARGAR °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
        [Test]
        public void Test1_Crear()
        {//1. Probamos la clase creada DAO
            Assert.IsNotNull(adminDAO);
            //2. Declaramos e instacionamos la entidad de Dominio
            Administrador adminACrear = new Administrador();
            adminACrear.NoAdministrador = "Jorge Camarena";
            adminACrear.TxMail = "jorge.camarena@upc.com";
            adminACrear.FeNacimiento = "03/12/1989";
            adminACrear.TxtClave = "23003";
            //3. declaramos la enidad
            Administrador adminCreado = null;
            //4. Probamos que no ocurra e error al ejecutar 
            Assert.DoesNotThrow(delegate
            {
                //5. Ejecutamos el metrodo a prbar.
                adminCreado = adminDAO.Crear(adminACrear);
                codigoGenerado = adminCreado.CoAdministrador;
            }, "Administrador Creado");
            //Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(adminCreado);
            //Probamos que el codigo generado sea mayor a 0
            Assert.GreaterOrEqual(adminCreado.CoAdministrador, 0);
            //Probamos que el nombnre registrado es igual al solicitado
            Assert.AreEqual(adminCreado.NoAdministrador, adminACrear.NoAdministrador);
        }
        //°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°° FIN DE TEST CREAR °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
        [Test]
        public void Test2_Obtener()
        {
             Assert.IsNotNull(adminDAO);
            int codigo  = codigoGenerado;
            // 2. Definimos los datos para la prueba
            // 3. Declaramos la entidad que contendrá el resultado
            Administrador adminObtenido = null;
            // 4. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                adminObtenido = adminDAO.Obtener(codigo);
            });
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(adminObtenido);
            Assert.AreEqual(adminObtenido.CoAdministrador, codigo);
            Assert.IsNotNullOrEmpty(adminObtenido.NoAdministrador);
            Assert.IsNotNullOrEmpty(adminObtenido.TxMail);
            //Assert.Less(adminObtenido.FeNacimiento, Convert.ToDateTime("1989"));
            Assert.IsNotNullOrEmpty(adminObtenido.TxtClave);

        }
        //°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°° FIN DE TEST OBTENER °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
        [Test]
        public void Test3_Modificar()
        {
            // 1. Clase a probar: LocalDAO
            codigoGenerado = 1;
            // 2. Declaramos e instanciamos la entidad de dominio
            Administrador administradorAModificar = adminDAO.Obtener(codigoGenerado);
            administradorAModificar.CoAdministrador = codigoGenerado;
            administradorAModificar.NoAdministrador = "Luis Benites";
            administradorAModificar.TxMail = "luis.be@genits.com";
            administradorAModificar.FeNacimiento = "12/11/1978";
            administradorAModificar.TxtClave = "323232";
            // 3. Declaramos la entidad que contendrá el resultado
            Administrador administradorModificado = null;
            // 4. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                administradorModificado = adminDAO.Modificar(administradorAModificar);
            });
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(administradorModificado);
            // Probamos que el código generado sea mayor a 0
            Assert.Greater(administradorModificado.CoAdministrador, 0);
        }
        //°°°°°°°°°°°°°°°°°°°°°°°°°°°° Fin de Tes Modificar °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
        [Test]
        public void Test4_Eliminar()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(adminDAO);
            // 2. Definimos la entidad que contendrá el resultado
            Administrador administradorExistente = adminDAO.Obtener(1);
            // 3. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                adminDAO.Eliminar(administradorExistente);
            }, "LOCAL ELIMINADO !");
            // Probamos que la entidad ya no existe
            Assert.IsNull(adminDAO.Obtener(codigoGenerado));
        }
        //°°°°°°°°°°°°°°°°°°°°°°°°°°°°° FIN DE TEST ELIMINAR °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
        [Test]
        public void Test5_ListarTodos()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(adminDAO);
            // 2. Declaramos la entidad que contendrá el resultado
            ICollection<Administrador> administradorEncontrados = null;
            // 3. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                administradorEncontrados = adminDAO.ListarTodos();
            }, "lOCAL LISTADO");
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(administradorEncontrados);
            // Probamos que la cantidad de locales encontrados sea 2
            Assert.GreaterOrEqual(administradorEncontrados.Count, 2);
            // Probamos que cada local contenga la cadena de búsqueda en su nombre
            foreach (Administrador administradaEncontrado in administradorEncontrados)
            {
                Assert.IsNotNull(administradaEncontrado);
                Assert.IsInstanceOf(typeof(Administrador), administradaEncontrado);
            }
        }
        //°°°°°°°°°°°°°°°°°°°°°°°° FIN DE TEST LISTAR °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°
        [Test]
        public void Test6_ListarXemailYClave()
        {
            // 1. Clase a probar: LocalDAO
            Assert.IsNotNull(adminDAO);
            // 2. Definimos los datos para la prueba
            string email = "larrylescano@gmail.com"; // Rock *
            string clave = "2009"; // Rock *
            // 3. Declaramos la entidad que contendrá el resultado
            ICollection<Administrador> administradorEncontrados = null;
            // 4. Probamos que no ocurra error al ejecutar el método
            Assert.DoesNotThrow(delegate
            {
                // 5. Ejecutamos el método a probar
                administradorEncontrados = adminDAO.ListarXMailYClave(email,clave);
            });
            // Probamos que la entidad resultante no sea nula
            Assert.IsNotNull(administradorEncontrados);
            // Probamos que la cantidad de locales encontrados sea 2
            Assert.AreEqual(administradorEncontrados.Count, 1);
            // Probamos que cada local contenga la cadena de búsqueda en su nombre
            foreach (Administrador administradorEncontrado in administradorEncontrados)
            {
                Assert.IsTrue(administradorEncontrado.TxMail.Contains(email));
                Assert.IsTrue(administradorEncontrado.TxtClave.Contains(clave));
            }
        }
        //[TestFixtureTearDown]
        //public void FinalizarPruebas()
        //{
            
        //}

    }
}